home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / chptrb.cpp < prev    next >
C/C++ Source or Header  |  1999-03-14  |  5KB  |  164 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- // 
  5. // C++ Source Code File Name: chptrb.cpp 
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer   
  8. // File Creation Date: 02/07/1997  
  9. // Date Last Modified: 03/15/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ------------- Program Description and Details ------------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. The CachePtrb class is used as a data indepentent base class for
  32. the CachePtr class. Cache pointers are used to work in conjunction
  33. with the reference counted cache buckets. Each cache pointer stores
  34. the file address of the object being poined to, a pointer to the
  35. bucket containing the memory buffer of the object, and a pointer
  36. to the cache the cache pointer is connected to.
  37. */
  38. // ----------------------------------------------------------- // 
  39. #include "chptrb.h"
  40. #include "bucket.h"
  41. #include "cacheb.h"
  42.  
  43. CachePtrb::CachePtrb(Cacheb &c, FAU p)
  44. // General cache pointer constructor. Note that a cache
  45. // is required. The cache pointer stays unbound untill needed.
  46. {
  47.   cache = &c; Address = p; bound = 0; bkt = 0;
  48. }
  49.  
  50. CachePtrb::CachePtrb(const CachePtrb &c)
  51. // Copy constructor. Note that destination cache pointer
  52. // will not be bound until needed, even if source is bound.
  53. {
  54.   Address = c.Address; bkt = c.bkt; cache = c.cache; bound = 0;
  55. }
  56.  
  57. Bucketb *CachePtrb::Alloc(size_t n, FAU p)
  58. // Allocates n bytes of room (presumably the size of the
  59. // data in the bucket) at address p in the cache's
  60. // file, and sets up a cache bucket to support it.
  61. // If p != 0, it means the room has already been allocated.
  62. // Note that ReserveBkt will setup bucket's address,
  63. // cache pointer and refcnt, but doesn't load any data.
  64. // Returns a pointer to the bucket, or 0 if couldn't
  65. // allocate.
  66. {
  67.   Release(); // Let go of any currently bound data
  68.   if (p == 0) p = cache->fptr->Alloc(n);
  69.   bkt = cache->ReserveBkt(p, 0);
  70.   if (bkt) {
  71.      bkt->SetDirty(); // Data modified by constructor
  72.      Address = p;
  73.      bound = 1;
  74.   }
  75.   else {
  76.      Address = 0; // bound will = 0 here as well
  77.   }
  78.   return bkt;
  79. }
  80.  
  81. void CachePtrb::Delete(unsigned n)
  82. // Deallocates the file data pointed to by this cache pointer, 
  83. // of size n. Deallocation only takes place if this cache pointer is
  84. // pointing to a bucket bound by no one else. Cache pointer is unbound
  85. // afterwards and both the bucket and cache pointer are made null.
  86. {
  87.   if (bound && bkt->IsLocked() == 1 ||
  88.       !bound && (!bkt || !bkt->IsLocked())) {
  89.      cache->fptr->Remove(Address);
  90.      Release();
  91.      bkt->MakeNull();
  92.      Address = 0;
  93.   }
  94.   else
  95. #ifdef CPP_EXCEPTIONS
  96.     throw CDanglingPtr();
  97. #else
  98.     Error->SignalException(EHandler::DanglingPtr);
  99. #endif
  100. }
  101.  
  102. void CachePtrb::Copy(const CachePtrb &c)
  103. // Copies one cache pointer into another. Note that the destination
  104. // cache pointer isn't bound, even if the source cache pointer is.
  105. {
  106.   Release();  
  107.   Address = c.Address;
  108.   bkt = c.bkt;
  109.   bound = 0;
  110.   cache = c.cache;
  111. }
  112.  
  113. void CachePtrb::Bind()
  114. // Binds the cache pointer to a bucket containing data stored at
  115. // file location address. Note that it may already be pointing
  116. // to the correct bucket. Assumes bucket is not already bound.
  117. {
  118.   
  119.   if (bkt && bkt->Address == Address) { // Fast binding
  120.     if (Address) {
  121.       bkt->Lock();
  122.       cache->FastBind();
  123.       bound = 1;
  124.     }
  125.     else
  126. #ifdef CPP_EXCEPTIONS
  127.       throw CNullPtr();
  128. #else
  129.       Error->SignalException(EHandler::NullPtr);
  130. #endif
  131.   }
  132.   else {
  133.     bkt = cache->ReserveBkt(Address, 1);
  134.     if (bkt)
  135.       bound = 1;
  136.     else
  137. #ifdef CPP_EXCEPTIONS
  138.       throw CNullPtr();
  139. #else
  140.       Error->SignalException(EHandler::NullPtr);
  141. #endif
  142.   }
  143. }
  144.  
  145. void CachePtrb::Release()
  146. // Signal to the bucket that it is through with it.
  147. {
  148.   if (bound) {
  149.      bkt->Unlock();
  150.      bound = 0;
  151.   }
  152. }
  153.  
  154. void CachePtrb::NotifyUseOf()
  155. // Moves the referenced bucket to the front of the
  156. // cache queue. For cache performance tuning.
  157. {
  158.   if (bound) cache->MoveToFront(bkt);
  159. }
  160. // ----------------------------------------------------------- //
  161. // ------------------------------- //
  162. // --------- End of File --------- //
  163. // ------------------------------- //
  164.